// pages/index/index.js
const { getBanners } = require("../../api/banner.js");
const { getProducts } = require("../../api/product.js");
const { checkNetworkStatus } = require("../../utils/request.js");
const { getCurrentEnvInfo, switchEnvironment } = require("../../config/api.js");

Page({
  data: {
    userInfo: {},
    hasUserInfo: false,
    canIUse: wx.canIUse("button.open-type.getUserInfo"),
    canIUseGetUserProfile: false,
    canIUseOpenData:
      wx.canIUse("open-data.type.userAvatarUrl") &&
      wx.canIUse("open-data.type.userNickName"),
    bannerList: [], // 轮播图数据
    productList: [], // 商品列表数据
    productLoading: false, // 商品加载状态
    productPageIndex: 1, // 当前页码
    productPageSize: 10, // 每页数量
    productTotalCount: 0, // 商品总条数
    hasMoreProducts: true, // 是否还有更多商品
    loadingMore: false, // 是否正在加载更多
    // 搜索相关数据
    searchExpanded: true, // 搜索框始终展开
    searchKeyword: "", // 搜索关键词
    searchFocus: false, // 搜索框是否聚焦
    searchSuggestions: [], // 搜索建议
    scrollTop: 0, // 页面滚动位置
    isAuthorized: false, // 用户是否已授权
    isLeader: false, // 用户是否为团长
    showDistributorApply: false, // 是否显示分销商申请按钮
    bannerMarginTop: "128rpx", // 轮播图容器的上边距
  },

  onLoad() {
    if (wx.getUserProfile) {
      this.setData({
        canIUseGetUserProfile: true,
      });
    }

    // 立即设置默认数据，确保页面有内容显示
    this.setDefaultBanners();
    this.setDefaultProducts();

    // 显示当前环境信息（调试用）
    this.showEnvironmentInfo();
    // 检查网络状态
    this.checkNetworkAndLoad();
  },

  onShow() {
    // 主动更新TabBar选中状态
    const app = getApp();
    app.updateCustomTabBar();

    // 恢复页面状态
    this.restorePageState();

    // 恢复滚动位置
    this.restoreScrollPosition();

    // 检查并恢复商品数据
    this.ensureProductData();

    // 刷新授权状态
    this.checkAuthStatus();

    // 检查用户团长状态
    this.checkLeaderStatus();
  },

  onHide() {
    // 保存页面状态
    this.savePageState();
  },

  onReady() {
    // 页面渲染完成后再次确保轮播图加载
    // 动态调整轮播图容器的上边距
    this.adjustBannerMargin();

    // 真机预览时在页面渲染完成后再次恢复滚动位置
    setTimeout(() => {
      this.restoreScrollPosition();
    }, 1500);
  },

  // 页面滚动事件
  onPageScroll(e) {
    const scrollTop = e.scrollTop;
    this.setData({
      scrollTop: scrollTop,
      currentScrollTop: scrollTop, // 实时记录当前滚动位置
    });

    // 同时保存到全局变量，确保真机能获取到
    getApp().globalData = getApp().globalData || {};
    getApp().globalData.homeScrollPosition = scrollTop;

    // 移除自动收起搜索框的功能，搜索框保持展开状态
  },

  // 页面触底事件 - 自动加载更多
  onReachBottom() {
    console.log("页面触底，尝试加载更多商品");
    console.log(
      "当前状态 - loadingMore:",
      this.data.loadingMore,
      "hasMoreProducts:",
      this.data.hasMoreProducts,
      "productList.length:",
      this.data.productList.length
    );
    this.loadMoreProducts();
  },

  // 下拉刷新事件
  onPullDownRefresh() {
    this.refreshPageData();
  },

  // 刷新页面数据
  async refreshPageData() {
    try {
      console.log("开始刷新页面数据...");

      // 显示刷新提示
      wx.showToast({
        title: "正在刷新...",
        icon: "loading",
        duration: 1000,
      });

      // 清除滚动位置记录，避免刷新后位置错乱
      this.clearScrollPosition();

      // 重置分页信息
      this.setData({
        productPageIndex: 1,
        productList: [],
        hasMoreProducts: true,
        loadingMore: false,
        productTotalCount: 0,
        needRestorePagination: false,
      });

      // 并行刷新轮播图和商品列表
      await Promise.all([this.loadBanners(), this.loadProducts()]);

      console.log("页面数据刷新完成");

      // 停止下拉刷新动画
      wx.stopPullDownRefresh();

      // 显示刷新成功提示
      wx.showToast({
        title: "刷新成功",
        icon: "success",
        duration: 1500,
      });
    } catch (error) {
      console.error("刷新页面数据失败:", error);

      // 停止下拉刷新动画
      wx.stopPullDownRefresh();

      // 显示刷新失败提示
      wx.showToast({
        title: "刷新失败，请重试",
        icon: "none",
        duration: 2000,
      });
    }
  },

  // 加载轮播图数据
  async loadBanners() {
    try {
      console.log("开始加载轮播图数据...");
      const res = await getBanners();
      console.log("轮播图API响应:", res);

      if (res && res.data && res.data.length > 0) {
        this.setData({
          bannerList: res.data,
        });
        console.log("轮播图数据加载成功:", res.data);
      } else {
        console.log("轮播图数据为空，使用默认数据");
        this.setDefaultBanners();
      }
    } catch (error) {
      console.error("加载轮播图失败:", error);
      console.log("使用默认轮播图数据");
      this.setDefaultBanners();
    }
  },

  // 设置默认轮播图
  setDefaultBanners() {
    console.log("设置默认轮播图数据");
    this.setData({
      bannerList: [
        {
          id: "default1",
          bannerName: "嗨翻购 - 三级分销电商",
          bannerImage: "https://picsum.photos/750/300?random=1",
          status: 1,
        },
        {
          id: "default2",
          bannerName: "优质商品推荐",
          bannerImage: "https://picsum.photos/750/300?random=2",
          status: 1,
        },
        {
          id: "default3",
          bannerName: "分销商招募中",
          bannerImage: "https://picsum.photos/750/300?random=3",
          status: 1,
        },
      ],
    });
    console.log("默认轮播图数据设置完成:", this.data.bannerList);
  },

  // 显示环境信息（调试用）
  showEnvironmentInfo() {
    const envInfo = getCurrentEnvInfo();
    console.log("=== 环境信息 ===");
    console.log("检测到的环境:", envInfo.detectedEnv);
    console.log("手动指定的环境:", envInfo.manualEnv);
    console.log("是否手机预览:", envInfo.isMobilePreview);
    console.log("当前使用的域名:", envInfo.currentBaseURL);
    console.log("实际环境:", envInfo.actualEnv);
    console.log("================");

    // 在开发环境下显示环境信息
    if (envInfo.detectedEnv === "development") {
      wx.showModal({
        title: "环境信息",
        content: `当前环境: ${envInfo.actualEnv}\n域名: ${
          envInfo.currentBaseURL
        }\n手机预览: ${envInfo.isMobilePreview ? "是" : "否"}`,
        showCancel: true,
        cancelText: "切换环境",
        confirmText: "确定",
        success: (res) => {
          if (res.cancel) {
            this.showEnvironmentSwitch();
          }
        },
      });
    }
  },

  // 显示环境切换选项
  showEnvironmentSwitch() {
    wx.showActionSheet({
      itemList: [
        "development (本地IP)",
        "test (测试环境)",
        "production (生产环境)",
        "网络诊断工具",
        "清除手动设置",
      ],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            switchEnvironment("development");
            break;
          case 1:
            switchEnvironment("test");
            break;
          case 2:
            switchEnvironment("production");
            break;
          case 3:
            // 网络诊断功能已移除
            wx.showToast({
              title: "网络诊断功能已移除",
              icon: "none",
            });
            break;
          case 4:
            wx.removeStorageSync("api_env");
            wx.showToast({
              title: "已清除手动设置",
              icon: "success",
            });
            break;
        }
      },
    });
  },

  // 检查网络状态并加载数据
  async checkNetworkAndLoad() {
    try {
      // 显示当前环境信息
      const envInfo = getCurrentEnvInfo();
      console.log("=== 网络检查开始 ===");
      console.log("当前环境:", envInfo.actualEnv);
      console.log("当前域名:", envInfo.currentBaseURL);
      console.log("是否手机预览:", envInfo.isMobilePreview);

      // 检查网络状态
      const networkOk = await checkNetworkStatus();
      console.log("网络状态检查结果:", networkOk);

      if (!networkOk) {
        console.log("网络不可用，使用默认数据");
        this.setDefaultBanners();
        this.setDefaultProducts();
        return;
      }

      // 检查用户授权状态
      this.checkAuthStatus();

      // 加载数据
      await Promise.all([this.loadBanners(), this.loadProducts()]);
    } catch (error) {
      console.error("初始化失败:", error);
      // 使用默认数据
      this.setDefaultBanners();
      this.setDefaultProducts();
    }
  },

  // 检查用户授权状态
  checkAuthStatus() {
    const userStore = require("../../store/userStore.js");
    const isAuthorized = userStore.isLoggedIn();
    const userInfo = userStore.getUserInfo();

    this.setData({
      isAuthorized: isAuthorized,
      userInfo: userInfo || {},
      hasUserInfo: isAuthorized,
    });

    console.log("用户授权状态:", {
      isAuthorized,
      userInfo,
      hasToken: !!userStore.getToken(),
    });
  },

  // 加载商品列表数据
  async loadProducts(isLoadMore = false) {
    try {
      // 检查是否需要恢复分页数据
      if (this.data.needRestorePagination && !isLoadMore) {
        console.log("检测到需要恢复分页，开始恢复分页数据");
        await this.restorePaginationProducts();
        return;
      }

      if (isLoadMore) {
        this.setData({
          loadingMore: true,
        });
      } else {
        this.setData({
          productLoading: true,
          productPageIndex: 1,
          hasMoreProducts: true,
        });
      }

      console.log(
        "开始加载商品列表数据...",
        `页码: ${this.data.productPageIndex}`
      );
      const res = await getProducts({
        pageIndex: this.data.productPageIndex,
        pageSize: this.data.productPageSize,
      });

      console.log("商品列表API响应:", res);

      if (res && res.data && res.data.list && res.data.list.length > 0) {
        const newProductList = res.data.list;
        const currentProductList = isLoadMore ? this.data.productList : [];
        const totalCount = res.data.total || 0; // 获取总条数

        // 根据接口返回的分页参数判断是否还有更多商品
        const isLastPage = res.data.isLastPage || false; // 是否是最后一页
        const hasNextPage = res.data.hasNextPage || false; // 是否有下一页
        const currentCount = currentProductList.length; // 当前已加载的条数
        const newCount = currentCount + newProductList.length; // 加载后的总条数

        // 使用 isLastPage 或 !hasNextPage 来判断是否还有更多商品
        const hasMore = !isLastPage && hasNextPage;

        this.setData({
          productList: [...currentProductList, ...newProductList],
          productPageIndex: this.data.productPageIndex + 1,
          productTotalCount: totalCount,
          hasMoreProducts: hasMore,
        });

        // console.log("商品列表数据加载成功:", newProductList);
        // console.log("总条数:", totalCount);
        // console.log("当前已加载条数:", newCount);
        // console.log("接口返回isLastPage:", isLastPage);
        // console.log("接口返回hasNextPage:", hasNextPage);
        // console.log("是否还有更多:", hasMore);

        // 加载完成后再次检查是否还有更多商品
        setTimeout(() => {
          this.checkHasMoreProducts();
        }, 100);
      } else {
        if (!isLoadMore) {
          console.log("商品列表数据为空，使用默认数据");
          this.setDefaultProducts();
        } else {
          // 当没有更多数据时，根据接口返回的分页参数设置状态
          const isLastPage = res.data ? res.data.isLastPage || false : true;
          const hasNextPage = res.data ? res.data.hasNextPage || false : false;
          const hasMore = !isLastPage && hasNextPage;

          this.setData({
            hasMoreProducts: hasMore,
          });
          console.log(
            "没有更多数据，isLastPage:",
            isLastPage,
            "hasNextPage:",
            hasNextPage,
            "hasMore:",
            hasMore
          );
        }
      }
    } catch (error) {
      console.error("加载商品列表失败:", error);
      if (!isLoadMore) {
        console.log("使用默认商品数据");
        this.setDefaultProducts();
      }
    } finally {
      this.setData({
        productLoading: false,
        loadingMore: false,
      });
    }
  },

  // 设置默认商品数据
  setDefaultProducts() {
    console.log("设置默认商品数据");
    this.setData({
      productList: [
        {
          id: "default1",
          spuCode: "SPU001",
          spuName: "测试商品1",
          subTitle: "优质商品推荐",
          categoryId: "101",
          categoryName: "男装",
          labelId: "1",
          labelName: "热销",
          mainImage: "https://picsum.photos/200/200?random=1",
          skuCount: 3,
          unitPrice: 299,
          totalSales: 156,
        },
        {
          id: "default2",
          spuCode: "SPU002",
          spuName: "测试商品2",
          subTitle: "限时特价",
          categoryId: "102",
          categoryName: "女装",
          labelId: "2",
          labelName: null,
          mainImage: "https://picsum.photos/200/200?random=2",
          skuCount: 1,
          unitPrice: 199,
          totalSales: 89,
        },
        {
          id: "default3",
          spuCode: "SPU003",
          spuName: "多规格商品",
          subTitle: "多种规格可选",
          categoryId: "103",
          categoryName: "鞋类",
          labelId: "3",
          labelName: "爆款",
          mainImage: "https://picsum.photos/200/200?random=3",
          skuCount: 5,
          unitPrice: 399,
          totalSales: 234,
        },
      ],
    });
    console.log("默认商品数据设置完成:", this.data.productList);
  },

  // 动态调整轮播图容器的上边距
  adjustBannerMargin() {
    const query = wx.createSelectorQuery();
    query.select(".search-container").boundingClientRect();
    query.exec((res) => {
      if (res[0]) {
        const searchHeight = res[0].height;
        console.log("搜索容器高度:", searchHeight);
        // 设置轮播图容器的上边距为搜索容器高度
        this.setData({
          bannerMarginTop: searchHeight + "px",
        });
      }
    });
  },

  // 检查用户授权，未授权则弹出授权弹窗
  checkAuthAndProceed(callback) {
    if (this.data.isAuthorized) {
      // 已授权，直接执行回调
      callback && callback();
    } else {
      // 未授权，弹出授权弹窗
      this.showAuthModal(callback);
    }
  },

  // 显示授权弹窗
  showAuthModal(callback) {
    wx.showModal({
      title: "授权提示",
      content: "请先授权登录后使用完整功能",
      confirmText: "立即授权",
      cancelText: "暂不授权",
      success: (res) => {
        if (res.confirm) {
          // 用户点击确认，执行微信登录
          this.performWxLogin(callback);
        } else {
          // 用户取消授权，仅关闭弹窗，不执行任何跳转
          console.log("用户选择暂不授权，仅关闭弹窗");
        }
      },
    });
  },

  // 执行微信登录
  async performWxLogin(callback) {
    try {
      wx.showLoading({
        title: "登录中...",
        mask: true,
      });

      // 调用微信登录
      const userStore = require("../../store/userStore.js");
      const loginResult = await userStore.wxLogin();

      console.log("首页登录结果:", loginResult);

      wx.hideLoading();

      if (loginResult && (loginResult.token || loginResult.accessToken)) {
        console.log("登录成功，更新页面状态");

        // 获取用户信息
        const userStore = require("../../store/userStore.js");
        const userInfo = userStore.getUserInfo();

        // console.log("=== 用户信息详情 ===");
        // console.log("用户ID:", userStore.getUserId());
        // console.log("用户昵称:", userStore.getUserNickname());
        // console.log("用户手机:", userStore.getUserPhone());
        // console.log("OpenID:", userStore.getUserOpenId());
        // console.log("UnionID:", userStore.getUserUnionId());
        // console.log("会话ID:", userStore.getSessionId());
        // console.log("过期时间:", userStore.getExpiredTime());
        // console.log("完整用户信息:", userInfo);
        // console.log("==================");

        // 登录成功，更新页面状态
        this.setData({
          isAuthorized: true,
          userInfo: userInfo || {},
          hasUserInfo: true,
        });

        // 检查用户团长状态
        this.checkLeaderStatus();

        wx.showToast({
          title: "登录成功",
          icon: "success",
        });

        // 登录成功后执行回调
        callback && callback();

        // 检查是否需要返回到指定页面
        const returnToPage = getApp().globalData?.returnToPage;
        if (returnToPage) {
          console.log("授权成功，准备返回到:", returnToPage);
          // 清除返回页面标记
          delete getApp().globalData.returnToPage;

          // 延迟跳转，确保toast显示完成
          setTimeout(() => {
            wx.navigateTo({
              url: returnToPage,
            });
          }, 1500);
        }
      } else {
        console.error("登录失败，loginResult:", loginResult);
        throw new Error("登录失败，未获取到token");
      }
    } catch (error) {
      wx.hideLoading();
      console.error("微信登录失败:", error);

      wx.showModal({
        title: "登录失败",
        content: error.message || "登录过程中发生错误，请重试",
        showCancel: false,
        success: () => {
          // 登录失败后执行回调
          callback && callback();
        },
      });
    }
  },

  // 轮播图点击事件
  onBannerTap(e) {
    const banner = e.currentTarget.dataset.banner;
    this.checkAuthAndProceed(() => {
      if (banner.spuId) {
        wx.navigateTo({
          url: `/pages/product/product?id=${banner.spuId}`,
        });
      } else {
        wx.switchTab({
          url: "/pages/category/category",
        });
      }
    });
  },

  // 搜索相关功能

  // 搜索按钮点击事件
  performSearchFromButton() {
    this.checkAuthAndProceed(() => {
      const keyword = this.data.searchKeyword;
      if (!keyword.trim()) {
        wx.showToast({
          title: "请输入搜索关键词",
          icon: "none",
        });
        return;
      }
      this.performSearch(keyword);
    });
  },

  // 取消搜索
  cancelSearch() {
    this.setData({
      searchExpanded: false,
      searchFocus: false,
      searchKeyword: "",
      searchSuggestions: [],
    });
  },

  // 搜索输入事件
  onSearchInput(e) {
    const keyword = e.detail.value;
    this.setData({
      searchKeyword: keyword,
    });

    // 如果有关键词，显示搜索建议
    if (keyword.trim()) {
      this.getSearchSuggestions(keyword);
    } else {
      this.setData({
        searchSuggestions: [],
      });
    }
  },

  // 搜索确认事件
  onSearchConfirm(e) {
    this.checkAuthAndProceed(() => {
      const keyword = e.detail.value;
      this.performSearch(keyword);
    });
  },

  // 清除搜索
  clearSearch() {
    this.setData({
      searchKeyword: "",
      searchSuggestions: [],
    });
  },

  // 选择搜索建议
  selectSuggestion(e) {
    this.checkAuthAndProceed(() => {
      const suggestion = e.currentTarget.dataset.suggestion;
      this.setData({
        searchKeyword: suggestion.name,
        searchSuggestions: [],
      });
      this.performSearch(suggestion.name);
    });
  },

  // 获取搜索建议
  getSearchSuggestions(keyword) {
    // 模拟搜索建议数据
    const suggestions = [
      { id: 1, name: `${keyword} 手机` },
      { id: 2, name: `${keyword} 电脑` },
      { id: 3, name: `${keyword} 服装` },
      { id: 4, name: `${keyword} 鞋子` },
      { id: 5, name: `${keyword} 包包` },
    ].slice(0, 5); // 最多显示5个建议

    this.setData({
      searchSuggestions: suggestions,
    });
  },

  // 执行搜索
  performSearch(keyword) {
    if (!keyword.trim()) {
      wx.showToast({
        title: "请输入搜索关键词",
        icon: "none",
      });
      return;
    }

    console.log("执行搜索:", keyword);
    console.log("原始关键词:", keyword);
    console.log("编码后关键词:", encodeURIComponent(keyword));

    // 收起搜索框
    this.setData({
      searchExpanded: false,
      searchFocus: false,
      searchSuggestions: [],
    });

    // 跳转到搜索结果页面
    const encodedKeyword = encodeURIComponent(keyword);
    const searchUrl = `/pages/search/search?keyword=${encodedKeyword}`;
    console.log("搜索URL:", searchUrl);

    wx.navigateTo({
      url: searchUrl,
    });
  },

  getUserProfile(e) {
    wx.getUserProfile({
      desc: "用于完善会员资料",
      success: (res) => {
        console.log(res);
        this.setData({
          userInfo: res.userInfo,
          hasUserInfo: true,
        });
      },
    });
  },

  getUserInfo(e) {
    console.log(e);
    this.setData({
      userInfo: e.detail.userInfo,
      hasUserInfo: true,
    });
  },

  // 促销页面
  navigateToPromotion() {
    this.checkAuthAndProceed(() => {
      this.recordScrollBeforeNavigate();
      wx.navigateTo({
        url: "/pages/promotion/promotion",
      });
    });
  },

  // 签到
  navigateToSignIn() {
    this.checkAuthAndProceed(() => {
      this.recordScrollBeforeNavigate();
      wx.navigateTo({
        url: "/pages/sign-in/sign-in",
      });
    });
  },

  // 团长申请
  navigateToDistributor() {
    this.checkAuthAndProceed(() => {
      this.recordScrollBeforeNavigate();
      wx.navigateTo({
        url: "/pages/distributor/distributor",
      });
    });
  },

  // 检查用户团长状态
  checkLeaderStatus() {
    const userStore = require("../../store/userStore.js");
    const userInfo = userStore.getUserInfo();

    if (userInfo && userInfo.isLeader !== undefined) {
      const isLeader = userInfo.isLeader === 1 || userInfo.isLeader === true;
      const showDistributorApply = !isLeader; // 如果不是团长，则显示分销商申请按钮

      console.log("用户团长状态检查:", {
        isLeader: isLeader,
        showDistributorApply: showDistributorApply,
        userInfo: userInfo,
      });

      this.setData({
        isLeader: isLeader,
        showDistributorApply: showDistributorApply,
      });
    } else {
      // 如果用户信息中没有团长状态（包括未授权用户），默认显示分销商申请按钮
      console.log("用户信息中无团长状态（可能未授权），默认显示分销商申请按钮");
      this.setData({
        isLeader: false,
        showDistributorApply: true,
      });
    }
  },

  // 分销商申请按钮点击事件
  navigateToDistributorApply() {
    // 检查用户是否已授权
    const userStore = require("../../store/userStore.js");
    const isLoggedIn = userStore.isLoggedIn();

    if (!isLoggedIn) {
      // 未授权用户，先进行授权
      this.checkAuthAndProceed(() => {
        this.recordScrollBeforeNavigate();
        wx.navigateTo({
          url: "/pages/apply/apply",
        });
      });
    } else {
      // 已授权用户，直接跳转
      this.recordScrollBeforeNavigate();
      wx.navigateTo({
        url: "/pages/apply/apply",
      });
    }
  },

  // 商品点击事件（来自组件）
  onProductTap(e) {
    console.log("商品被点击，开始处理...");
    this.checkAuthAndProceed(() => {
      const { product } = e.detail;
      console.log("商品信息:", product);

      if (product && product.id) {
        console.log("准备记录滚动位置并跳转到商品详情页");

        // 立即记录当前滚动位置和分页信息
        const currentScrollTop =
          this.data.scrollTop || this.data.currentScrollTop || 0;
        const currentPageIndex = this.data.productPageIndex || 1;
        const currentProductCount = this.data.productList.length || 0;

        console.log("当前页面滚动位置:", currentScrollTop);
        console.log("当前分页索引:", currentPageIndex);
        console.log("当前商品数量:", currentProductCount);

        if (currentScrollTop > 0) {
          // 保存滚动位置
          wx.setStorageSync("homeScrollPosition", currentScrollTop);
          getApp().globalData = getApp().globalData || {};
          getApp().globalData.homeScrollPosition = currentScrollTop;
          console.log("立即保存滚动位置:", currentScrollTop);

          // 保存分页信息
          wx.setStorageSync("homePageIndex", currentPageIndex);
          wx.setStorageSync("homeProductCount", currentProductCount);
          getApp().globalData.homePageIndex = currentPageIndex;
          getApp().globalData.homeProductCount = currentProductCount;
          console.log(
            "保存分页信息 - 页码:",
            currentPageIndex,
            "商品数:",
            currentProductCount
          );
        }

        // 延迟记录滚动位置，确保滚动停止
        setTimeout(() => {
          console.log("延迟50ms后开始记录滚动位置");
          this.recordScrollPosition();
        }, 50);

        wx.navigateTo({
          url: `/pages/product-detail/product-detail?productId=${product.id}`,
        });
      } else {
        console.log("商品信息错误，无法跳转");
        wx.showToast({
          title: "商品信息错误",
          icon: "none",
        });
      }
    });
  },

  // 记录滚动位置
  recordScrollPosition() {
    console.log("开始记录滚动位置...");

    // 方法1：使用wx.createSelectorQuery()
    const query = wx.createSelectorQuery();
    query.selectViewport().scrollOffset();
    query.exec((res) => {
      console.log("滚动位置查询结果:", res);

      let scrollTop = 0;

      if (res && res[0] && res[0].scrollTop > 0) {
        scrollTop = res[0].scrollTop;
        console.log("通过createSelectorQuery获取到滚动位置:", scrollTop);
      } else {
        // 方法2：使用页面数据中的scrollTop
        scrollTop = this.data.scrollTop || 0;
        console.log("通过页面数据获取到滚动位置:", scrollTop);

        // 方法3：如果还是0，尝试使用页面滚动事件记录的位置
        if (scrollTop === 0) {
          scrollTop = this.data.currentScrollTop || 0;
          console.log("通过页面滚动事件获取到滚动位置:", scrollTop);
        }
      }

      // 无论滚动位置是否为0，都要保存（包括页面顶部位置）
      this.setData({
        scrollTop: scrollTop,
      });

      // 同时保存到本地存储
      wx.setStorageSync("homeScrollPosition", scrollTop);
      console.log("已保存滚动位置到本地存储:", scrollTop);

      // 真机预览时额外保存到全局变量
      getApp().globalData = getApp().globalData || {};
      getApp().globalData.homeScrollPosition = scrollTop;
      console.log("已保存滚动位置到全局变量:", scrollTop);
    });
  },

  // 保存页面状态
  savePageState() {
    console.log("保存页面状态");

    // 保存滚动位置
    this.recordScrollPosition();

    // 保存商品数据
    if (this.data.productList.length > 0) {
      const pageState = {
        productList: this.data.productList,
        productPageIndex: this.data.productPageIndex,
        productTotalCount: this.data.productTotalCount,
        hasMoreProducts: this.data.hasMoreProducts,
        bannerList: this.data.bannerList,
        timestamp: Date.now(),
      };

      wx.setStorageSync("homePageState", pageState);
      console.log("页面状态已保存");
    }
  },

  // 恢复页面状态
  restorePageState() {
    console.log("恢复页面状态");

    const pageState = wx.getStorageSync("homePageState");
    if (pageState && pageState.timestamp) {
      // 检查数据是否过期（5分钟内有效）
      const isExpired = Date.now() - pageState.timestamp > 5 * 60 * 1000;

      if (
        !isExpired &&
        pageState.productList &&
        pageState.productList.length > 0
      ) {
        console.log("恢复保存的页面状态");
        this.setData({
          productList: pageState.productList,
          productPageIndex: pageState.productPageIndex,
          productTotalCount: pageState.productTotalCount,
          hasMoreProducts: pageState.hasMoreProducts,
          bannerList: pageState.bannerList || this.data.bannerList,
        });
        return true; // 表示成功恢复了状态
      }
    }

    return false; // 表示没有可恢复的状态
  },

  // 确保商品数据存在
  ensureProductData() {
    console.log("检查商品数据");

    // 如果商品列表为空，尝试恢复或重新加载
    if (this.data.productList.length === 0) {
      console.log("商品列表为空，尝试恢复或重新加载");

      // 先尝试从保存的状态恢复
      const restored = this.restorePageState();

      if (!restored) {
        // 如果没有保存的状态，重新加载数据
        console.log("没有保存的状态，重新加载数据");
        setTimeout(() => {
          this.loadBanners();
          this.loadProducts();
        }, 100);
      }
    } else {
      console.log("商品数据正常，无需重新加载");
    }
  },

  // 通用方法：在跳转前记录滚动位置
  recordScrollBeforeNavigate() {
    console.log("准备跳转页面，先记录滚动位置");

    // 立即记录当前滚动位置
    const currentScrollTop =
      this.data.scrollTop || this.data.currentScrollTop || 0;
    console.log("当前页面滚动位置:", currentScrollTop);

    // 无论滚动位置是否为0，都要保存（包括页面顶部位置）
    wx.setStorageSync("homeScrollPosition", currentScrollTop);
    getApp().globalData = getApp().globalData || {};
    getApp().globalData.homeScrollPosition = currentScrollTop;
    console.log("立即保存滚动位置:", currentScrollTop);

    // 延迟记录滚动位置，确保滚动停止
    setTimeout(() => {
      console.log("延迟50ms后开始记录滚动位置");
      this.recordScrollPosition();
    }, 50);
  },

  // 恢复分页商品数据
  async restorePaginationProducts() {
    console.log("开始恢复分页商品数据...");

    try {
      const targetPageIndex = this.data.productPageIndex;
      const targetProductCount = this.data.targetProductCount;

      console.log(
        "目标分页:",
        targetPageIndex,
        "目标商品数:",
        targetProductCount
      );

      // 从第一页开始加载，直到达到目标分页
      let currentPageIndex = 1;
      let allProducts = [];

      while (currentPageIndex <= targetPageIndex) {
        console.log("加载第", currentPageIndex, "页商品数据");

        const res = await getProducts({
          pageIndex: currentPageIndex,
          pageSize: this.data.productPageSize,
        });

        if (res && res.data && res.data.list && res.data.list.length > 0) {
          allProducts = [...allProducts, ...res.data.list];
          console.log(
            "第",
            currentPageIndex,
            "页加载完成，当前总商品数:",
            allProducts.length
          );

          // 如果已经达到目标商品数量，停止加载
          if (allProducts.length >= targetProductCount) {
            console.log("已达到目标商品数量，停止加载");
            break;
          }
        } else {
          console.log("第", currentPageIndex, "页没有更多商品，停止加载");
          break;
        }

        currentPageIndex++;
      }

      // 设置商品列表
      this.setData({
        productList: allProducts,
        productPageIndex: targetPageIndex + 1,
        productTotalCount: allProducts.length,
        hasMoreProducts: allProducts.length < this.data.productTotalCount,
        productLoading: false,
        needRestorePagination: false, // 清除恢复标记
      });

      console.log("分页商品数据恢复完成，总商品数:", allProducts.length);
    } catch (error) {
      console.error("恢复分页商品数据失败:", error);
      // 如果恢复失败，使用默认加载
      this.setData({
        needRestorePagination: false,
        productLoading: true,
        productPageIndex: 1,
      });
    }
  },

  // 恢复分页数据
  restorePaginationData() {
    console.log("开始恢复分页数据...");

    // 从多个来源读取分页信息
    const storagePageIndex = wx.getStorageSync("homePageIndex") || 0;
    const globalPageIndex = getApp().globalData?.homePageIndex || 0;
    const storageProductCount = wx.getStorageSync("homeProductCount") || 0;
    const globalProductCount = getApp().globalData?.homeProductCount || 0;

    const savedPageIndex = storagePageIndex || globalPageIndex;
    const savedProductCount = storageProductCount || globalProductCount;

    console.log(
      "本地存储分页信息 - 页码:",
      storagePageIndex,
      "商品数:",
      storageProductCount
    );
    console.log(
      "全局变量分页信息 - 页码:",
      globalPageIndex,
      "商品数:",
      globalProductCount
    );
    console.log(
      "最终使用分页信息 - 页码:",
      savedPageIndex,
      "商品数:",
      savedProductCount
    );

    if (savedPageIndex > 1 && savedProductCount > 0) {
      console.log(
        "需要恢复到分页:",
        savedPageIndex,
        "商品数量:",
        savedProductCount
      );

      // 设置分页信息
      this.setData({
        productPageIndex: savedPageIndex,
        productList: [], // 清空当前列表，等待重新加载
      });

      // 标记需要恢复分页
      this.data.needRestorePagination = true;
      this.data.targetProductCount = savedProductCount;

      console.log("已设置分页恢复标记");
    }
  },

  // 立即恢复滚动位置（避免闪屏）
  restoreScrollPositionImmediately() {
    console.log("立即恢复滚动位置，避免闪屏...");

    // 从多个来源读取滚动位置
    const storageScrollTop = wx.getStorageSync("homeScrollPosition") || 0;
    const globalScrollTop = getApp().globalData?.homeScrollPosition || 0;
    const savedScrollTop = storageScrollTop || globalScrollTop;

    console.log("本地存储滚动位置:", storageScrollTop);
    console.log("全局变量滚动位置:", globalScrollTop);
    console.log("最终使用滚动位置:", savedScrollTop);

    if (savedScrollTop > 0) {
      console.log("准备立即恢复滚动位置:", savedScrollTop);

      // 立即设置数据，避免页面抖动
      this.setData({
        scrollTop: savedScrollTop,
      });

      // 立即滚动到目标位置，不使用延迟
      wx.pageScrollTo({
        scrollTop: savedScrollTop,
        duration: 0,
      });
      console.log("立即恢复滚动位置:", savedScrollTop);
    }
  },

  // 恢复滚动位置
  restoreScrollPosition() {
    console.log("开始恢复滚动位置...");

    // 从多个来源读取滚动位置
    const storageScrollTop = wx.getStorageSync("homeScrollPosition") || 0;
    const globalScrollTop = getApp().globalData?.homeScrollPosition || 0;
    const savedScrollTop = storageScrollTop || globalScrollTop;

    console.log("本地存储滚动位置:", storageScrollTop);
    console.log("全局变量滚动位置:", globalScrollTop);
    console.log("最终使用滚动位置:", savedScrollTop);

    // 无论滚动位置是否为0，都要恢复（包括页面顶部位置）
    console.log(
      "准备恢复滚动位置:",
      savedScrollTop,
      "来源:",
      storageScrollTop !== undefined ? "本地存储" : "全局变量"
    );

    // 立即设置数据，避免页面抖动
    this.setData({
      scrollTop: savedScrollTop,
    });

    // 立即滚动到目标位置，不使用延迟
    wx.pageScrollTo({
      scrollTop: savedScrollTop,
      duration: 0,
    });
    console.log("立即恢复滚动位置:", savedScrollTop);

    // 真机需要多次确认位置，但间隔更短
    setTimeout(() => {
      wx.pageScrollTo({
        scrollTop: savedScrollTop,
        duration: 0,
      });
      console.log("第一次确认滚动位置:", savedScrollTop);
    }, 50);

    setTimeout(() => {
      wx.pageScrollTo({
        scrollTop: savedScrollTop,
        duration: 0,
      });
      console.log("第二次确认滚动位置:", savedScrollTop);
    }, 100);
  },

  // 清除滚动位置
  clearScrollPosition() {
    this.setData({
      scrollTop: 0,
    });
    wx.removeStorageSync("homeScrollPosition");
    console.log("清除滚动位置记录");
  },

  // 上拉加载更多商品
  async loadMoreProducts() {
    // 检查是否正在加载或没有更多商品
    if (this.data.loadingMore || !this.data.hasMoreProducts) {
      console.log(
        "跳过加载更多商品 - loadingMore:",
        this.data.loadingMore,
        "hasMoreProducts:",
        this.data.hasMoreProducts
      );
      return;
    }

    console.log("开始加载更多商品...");
    try {
      await this.loadProducts(true);
    } catch (error) {
      console.error("加载更多商品失败:", error);
      // 加载失败时显示提示
      wx.showToast({
        title: "加载失败，请重试",
        icon: "none",
        duration: 2000,
      });
    }
  },

  // 检查是否还有更多商品（基于接口返回的分页参数）
  checkHasMoreProducts() {
    const currentCount = this.data.productList.length;
    const totalCount = this.data.productTotalCount;
    const hasMoreProducts = this.data.hasMoreProducts;

    console.log(
      `检查是否还有更多商品: 当前${currentCount}条, 总计${totalCount}条, hasMoreProducts: ${hasMoreProducts}`
    );

    // 直接使用已经设置的hasMoreProducts状态，这个状态是基于接口返回的isLastPage和hasNextPage字段设置的
    console.log(`当前hasMoreProducts状态: ${hasMoreProducts}`);

    return hasMoreProducts;
  },

  // 商品详情（保留兼容性）
  navigateToProduct(e) {
    this.checkAuthAndProceed(() => {
      const product = e.currentTarget.dataset.product;
      if (product && product.id) {
        wx.navigateTo({
          url: `/pages/product/product?id=${product.id}`,
        });
      } else {
        wx.navigateTo({
          url: "/pages/product/product",
        });
      }
    });
  },

  // 查看更多商品
  navigateToMoreProducts() {
    this.checkAuthAndProceed(() => {
      wx.switchTab({
        url: "/pages/category/category",
      });
    });
  },

  onShareAppMessage() {
    return {
      title: "嗨翻购 - 快速申请，安全可靠",
      path: "/pages/index/index",
    };
  },
});
